// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.inventory.batch.no;

import com.fowo.api.common.model.PageSearch;
import java.util.Date;
import java.util.List;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class InventoryBatchNoSearchParamPo extends PageSearch {

  /**
   * 库存金额
   */
  private java.math.BigDecimal stockAmount;

  /**
   * 最小库存金额
   */
  private java.math.BigDecimal stockAmountMin;

  /**
   * 最大库存金额
   */
  private java.math.BigDecimal stockAmountMax;

  /**
   * 库存金额 比较(eq)
   */
  private java.math.BigDecimal stockAmountEq;
  /**
   * 库存金额 比较(neq)
   */
  private java.math.BigDecimal stockAmountNeq;
  /**
   * 库存金额 比较(gt)
   */
  private java.math.BigDecimal stockAmountGt;
  /**
   * 库存金额 比较(gte)
   */
  private java.math.BigDecimal stockAmountGte;
  /**
   * 库存金额 比较(lt)
   */
  private java.math.BigDecimal stockAmountLt;
  /**
   * 库存金额 比较(lte)
   */
  private java.math.BigDecimal stockAmountLte;
  /**
   * 库存金额 比较(contains)
   */
  private java.math.BigDecimal stockAmountContains;
  /**
   * 库存金额 比较(notcontains)
   */
  private java.math.BigDecimal stockAmountNotcontains;
  /**
   * 库存金额 比较(startswith)
   */
  private java.math.BigDecimal stockAmountStartswith;
  /**
   * 库存金额 比较(endswith)
   */
  private java.math.BigDecimal stockAmountEndswith;
  /**
   * 库存金额 比较(isnull)
   */
  private Boolean stockAmountIsnull;
  /**
   * 库存金额 比较(isnotnull)
   */
  private Boolean stockAmountIsnotnull;

  /**
   * 自定义单号子表id
   */
  private Long customBdId;

  /**
   * 最小自定义单号子表id
   */
  private Long customBdIdMin;

  /**
   * 最大自定义单号子表id
   */
  private Long customBdIdMax;

  /**
   * 自定义单号子表id 比较(eq)
   */
  private Long customBdIdEq;
  /**
   * 自定义单号子表id 比较(neq)
   */
  private Long customBdIdNeq;
  /**
   * 自定义单号子表id 比较(gt)
   */
  private Long customBdIdGt;
  /**
   * 自定义单号子表id 比较(gte)
   */
  private Long customBdIdGte;
  /**
   * 自定义单号子表id 比较(lt)
   */
  private Long customBdIdLt;
  /**
   * 自定义单号子表id 比较(lte)
   */
  private Long customBdIdLte;
  /**
   * 自定义单号子表id 比较(contains)
   */
  private Long customBdIdContains;
  /**
   * 自定义单号子表id 比较(notcontains)
   */
  private Long customBdIdNotcontains;
  /**
   * 自定义单号子表id 比较(startswith)
   */
  private Long customBdIdStartswith;
  /**
   * 自定义单号子表id 比较(endswith)
   */
  private Long customBdIdEndswith;
  /**
   * 自定义单号子表id 比较(isnull)
   */
  private Boolean customBdIdIsnull;
  /**
   * 自定义单号子表id 比较(isnotnull)
   */
  private Boolean customBdIdIsnotnull;

  /**
   * 自定义单号id
   */
  private Long customId;

  /**
   * 最小自定义单号id
   */
  private Long customIdMin;

  /**
   * 最大自定义单号id
   */
  private Long customIdMax;

  /**
   * 自定义单号id 比较(eq)
   */
  private Long customIdEq;
  /**
   * 自定义单号id 比较(neq)
   */
  private Long customIdNeq;
  /**
   * 自定义单号id 比较(gt)
   */
  private Long customIdGt;
  /**
   * 自定义单号id 比较(gte)
   */
  private Long customIdGte;
  /**
   * 自定义单号id 比较(lt)
   */
  private Long customIdLt;
  /**
   * 自定义单号id 比较(lte)
   */
  private Long customIdLte;
  /**
   * 自定义单号id 比较(contains)
   */
  private Long customIdContains;
  /**
   * 自定义单号id 比较(notcontains)
   */
  private Long customIdNotcontains;
  /**
   * 自定义单号id 比较(startswith)
   */
  private Long customIdStartswith;
  /**
   * 自定义单号id 比较(endswith)
   */
  private Long customIdEndswith;
  /**
   * 自定义单号id 比较(isnull)
   */
  private Boolean customIdIsnull;
  /**
   * 自定义单号id 比较(isnotnull)
   */
  private Boolean customIdIsnotnull;

  /**
   * 库龄批次号(模糊搜索)
   */
  private String stockAgeBatchNo;

  /**
   * 库龄批次号 比较(eq)
   */
  private String stockAgeBatchNoEq;
  /**
   * 库龄批次号 比较(neq)
   */
  private String stockAgeBatchNoNeq;
  /**
   * 库龄批次号 比较(gt)
   */
  private String stockAgeBatchNoGt;
  /**
   * 库龄批次号 比较(gte)
   */
  private String stockAgeBatchNoGte;
  /**
   * 库龄批次号 比较(lt)
   */
  private String stockAgeBatchNoLt;
  /**
   * 库龄批次号 比较(lte)
   */
  private String stockAgeBatchNoLte;
  /**
   * 库龄批次号 比较(contains)
   */
  private String stockAgeBatchNoContains;
  /**
   * 库龄批次号 比较(notcontains)
   */
  private String stockAgeBatchNoNotcontains;
  /**
   * 库龄批次号 比较(startswith)
   */
  private String stockAgeBatchNoStartswith;
  /**
   * 库龄批次号 比较(endswith)
   */
  private String stockAgeBatchNoEndswith;
  /**
   * 库龄批次号 比较(isnull)
   */
  private Boolean stockAgeBatchNoIsnull;
  /**
   * 库龄批次号 比较(isnotnull)
   */
  private Boolean stockAgeBatchNoIsnotnull;

  /**
   * 库龄批次号(精确搜索)
   */
  private List<String> stockAgeBatchNoInList;

  /**
   * 可用数量
   */
  private java.math.BigDecimal availableQty;

  /**
   * 最小可用数量
   */
  private java.math.BigDecimal availableQtyMin;

  /**
   * 最大可用数量
   */
  private java.math.BigDecimal availableQtyMax;

  /**
   * 可用数量 比较(eq)
   */
  private java.math.BigDecimal availableQtyEq;
  /**
   * 可用数量 比较(neq)
   */
  private java.math.BigDecimal availableQtyNeq;
  /**
   * 可用数量 比较(gt)
   */
  private java.math.BigDecimal availableQtyGt;
  /**
   * 可用数量 比较(gte)
   */
  private java.math.BigDecimal availableQtyGte;
  /**
   * 可用数量 比较(lt)
   */
  private java.math.BigDecimal availableQtyLt;
  /**
   * 可用数量 比较(lte)
   */
  private java.math.BigDecimal availableQtyLte;
  /**
   * 可用数量 比较(contains)
   */
  private java.math.BigDecimal availableQtyContains;
  /**
   * 可用数量 比较(notcontains)
   */
  private java.math.BigDecimal availableQtyNotcontains;
  /**
   * 可用数量 比较(startswith)
   */
  private java.math.BigDecimal availableQtyStartswith;
  /**
   * 可用数量 比较(endswith)
   */
  private java.math.BigDecimal availableQtyEndswith;
  /**
   * 可用数量 比较(isnull)
   */
  private Boolean availableQtyIsnull;
  /**
   * 可用数量 比较(isnotnull)
   */
  private Boolean availableQtyIsnotnull;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnSku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnSkuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnSkuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnSkuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnSkuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnSkuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnSkuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnSkuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnSkuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnSkuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnSkuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnSkuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnSkuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnSkuInList;

  /**
   * 店铺id(模糊搜索)
   */
  private String shopId;

  /**
   * 店铺id 比较(eq)
   */
  private String shopIdEq;
  /**
   * 店铺id 比较(neq)
   */
  private String shopIdNeq;
  /**
   * 店铺id 比较(gt)
   */
  private String shopIdGt;
  /**
   * 店铺id 比较(gte)
   */
  private String shopIdGte;
  /**
   * 店铺id 比较(lt)
   */
  private String shopIdLt;
  /**
   * 店铺id 比较(lte)
   */
  private String shopIdLte;
  /**
   * 店铺id 比较(contains)
   */
  private String shopIdContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private String shopIdNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private String shopIdStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private String shopIdEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;

  /**
   * 店铺id(精确搜索)
   */
  private List<String> shopIdInList;

  /**
   * 组织内码
   */
  private Long orgId;

  /**
   * 最小组织内码
   */
  private Long orgIdMin;

  /**
   * 最大组织内码
   */
  private Long orgIdMax;

  /**
   * 组织内码 比较(eq)
   */
  private Long orgIdEq;
  /**
   * 组织内码 比较(neq)
   */
  private Long orgIdNeq;
  /**
   * 组织内码 比较(gt)
   */
  private Long orgIdGt;
  /**
   * 组织内码 比较(gte)
   */
  private Long orgIdGte;
  /**
   * 组织内码 比较(lt)
   */
  private Long orgIdLt;
  /**
   * 组织内码 比较(lte)
   */
  private Long orgIdLte;
  /**
   * 组织内码 比较(contains)
   */
  private Long orgIdContains;
  /**
   * 组织内码 比较(notcontains)
   */
  private Long orgIdNotcontains;
  /**
   * 组织内码 比较(startswith)
   */
  private Long orgIdStartswith;
  /**
   * 组织内码 比较(endswith)
   */
  private Long orgIdEndswith;
  /**
   * 组织内码 比较(isnull)
   */
  private Boolean orgIdIsnull;
  /**
   * 组织内码 比较(isnotnull)
   */
  private Boolean orgIdIsnotnull;

  /**
   * 数据版本
   */
  private Long version;

  /**
   * 最小数据版本
   */
  private Long versionMin;

  /**
   * 最大数据版本
   */
  private Long versionMax;

  /**
   * 数据版本 比较(eq)
   */
  private Long versionEq;
  /**
   * 数据版本 比较(neq)
   */
  private Long versionNeq;
  /**
   * 数据版本 比较(gt)
   */
  private Long versionGt;
  /**
   * 数据版本 比较(gte)
   */
  private Long versionGte;
  /**
   * 数据版本 比较(lt)
   */
  private Long versionLt;
  /**
   * 数据版本 比较(lte)
   */
  private Long versionLte;
  /**
   * 数据版本 比较(contains)
   */
  private Long versionContains;
  /**
   * 数据版本 比较(notcontains)
   */
  private Long versionNotcontains;
  /**
   * 数据版本 比较(startswith)
   */
  private Long versionStartswith;
  /**
   * 数据版本 比较(endswith)
   */
  private Long versionEndswith;
  /**
   * 数据版本 比较(isnull)
   */
  private Boolean versionIsnull;
  /**
   * 数据版本 比较(isnotnull)
   */
  private Boolean versionIsnotnull;

  /**
   * 在途数量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小在途数量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大在途数量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 在途数量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 在途数量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 在途数量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 在途数量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 在途数量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 在途数量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 在途数量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 在途数量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 在途数量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 在途数量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 在途数量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 在途数量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 残次数量
   */
  private java.math.BigDecimal defectQty;

  /**
   * 最小残次数量
   */
  private java.math.BigDecimal defectQtyMin;

  /**
   * 最大残次数量
   */
  private java.math.BigDecimal defectQtyMax;

  /**
   * 残次数量 比较(eq)
   */
  private java.math.BigDecimal defectQtyEq;
  /**
   * 残次数量 比较(neq)
   */
  private java.math.BigDecimal defectQtyNeq;
  /**
   * 残次数量 比较(gt)
   */
  private java.math.BigDecimal defectQtyGt;
  /**
   * 残次数量 比较(gte)
   */
  private java.math.BigDecimal defectQtyGte;
  /**
   * 残次数量 比较(lt)
   */
  private java.math.BigDecimal defectQtyLt;
  /**
   * 残次数量 比较(lte)
   */
  private java.math.BigDecimal defectQtyLte;
  /**
   * 残次数量 比较(contains)
   */
  private java.math.BigDecimal defectQtyContains;
  /**
   * 残次数量 比较(notcontains)
   */
  private java.math.BigDecimal defectQtyNotcontains;
  /**
   * 残次数量 比较(startswith)
   */
  private java.math.BigDecimal defectQtyStartswith;
  /**
   * 残次数量 比较(endswith)
   */
  private java.math.BigDecimal defectQtyEndswith;
  /**
   * 残次数量 比较(isnull)
   */
  private Boolean defectQtyIsnull;
  /**
   * 残次数量 比较(isnotnull)
   */
  private Boolean defectQtyIsnotnull;

  /**
   * 陈列数量
   */
  private java.math.BigDecimal displayQty;

  /**
   * 最小陈列数量
   */
  private java.math.BigDecimal displayQtyMin;

  /**
   * 最大陈列数量
   */
  private java.math.BigDecimal displayQtyMax;

  /**
   * 陈列数量 比较(eq)
   */
  private java.math.BigDecimal displayQtyEq;
  /**
   * 陈列数量 比较(neq)
   */
  private java.math.BigDecimal displayQtyNeq;
  /**
   * 陈列数量 比较(gt)
   */
  private java.math.BigDecimal displayQtyGt;
  /**
   * 陈列数量 比较(gte)
   */
  private java.math.BigDecimal displayQtyGte;
  /**
   * 陈列数量 比较(lt)
   */
  private java.math.BigDecimal displayQtyLt;
  /**
   * 陈列数量 比较(lte)
   */
  private java.math.BigDecimal displayQtyLte;
  /**
   * 陈列数量 比较(contains)
   */
  private java.math.BigDecimal displayQtyContains;
  /**
   * 陈列数量 比较(notcontains)
   */
  private java.math.BigDecimal displayQtyNotcontains;
  /**
   * 陈列数量 比较(startswith)
   */
  private java.math.BigDecimal displayQtyStartswith;
  /**
   * 陈列数量 比较(endswith)
   */
  private java.math.BigDecimal displayQtyEndswith;
  /**
   * 陈列数量 比较(isnull)
   */
  private Boolean displayQtyIsnull;
  /**
   * 陈列数量 比较(isnotnull)
   */
  private Boolean displayQtyIsnotnull;

  /**
   * 锁库数量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小锁库数量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大锁库数量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 锁库数量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 锁库数量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 锁库数量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 锁库数量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 锁库数量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 锁库数量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 锁库数量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 锁库数量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 锁库数量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 锁库数量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 锁库数量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 锁库数量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 辅助数量
   */
  private java.math.BigDecimal auxQty;

  /**
   * 最小辅助数量
   */
  private java.math.BigDecimal auxQtyMin;

  /**
   * 最大辅助数量
   */
  private java.math.BigDecimal auxQtyMax;

  /**
   * 辅助数量 比较(eq)
   */
  private java.math.BigDecimal auxQtyEq;
  /**
   * 辅助数量 比较(neq)
   */
  private java.math.BigDecimal auxQtyNeq;
  /**
   * 辅助数量 比较(gt)
   */
  private java.math.BigDecimal auxQtyGt;
  /**
   * 辅助数量 比较(gte)
   */
  private java.math.BigDecimal auxQtyGte;
  /**
   * 辅助数量 比较(lt)
   */
  private java.math.BigDecimal auxQtyLt;
  /**
   * 辅助数量 比较(lte)
   */
  private java.math.BigDecimal auxQtyLte;
  /**
   * 辅助数量 比较(contains)
   */
  private java.math.BigDecimal auxQtyContains;
  /**
   * 辅助数量 比较(notcontains)
   */
  private java.math.BigDecimal auxQtyNotcontains;
  /**
   * 辅助数量 比较(startswith)
   */
  private java.math.BigDecimal auxQtyStartswith;
  /**
   * 辅助数量 比较(endswith)
   */
  private java.math.BigDecimal auxQtyEndswith;
  /**
   * 辅助数量 比较(isnull)
   */
  private Boolean auxQtyIsnull;
  /**
   * 辅助数量 比较(isnotnull)
   */
  private Boolean auxQtyIsnotnull;

  /**
   * 辅助计量内码
   */
  private Long auxId;

  /**
   * 最小辅助计量内码
   */
  private Long auxIdMin;

  /**
   * 最大辅助计量内码
   */
  private Long auxIdMax;

  /**
   * 辅助计量内码 比较(eq)
   */
  private Long auxIdEq;
  /**
   * 辅助计量内码 比较(neq)
   */
  private Long auxIdNeq;
  /**
   * 辅助计量内码 比较(gt)
   */
  private Long auxIdGt;
  /**
   * 辅助计量内码 比较(gte)
   */
  private Long auxIdGte;
  /**
   * 辅助计量内码 比较(lt)
   */
  private Long auxIdLt;
  /**
   * 辅助计量内码 比较(lte)
   */
  private Long auxIdLte;
  /**
   * 辅助计量内码 比较(contains)
   */
  private Long auxIdContains;
  /**
   * 辅助计量内码 比较(notcontains)
   */
  private Long auxIdNotcontains;
  /**
   * 辅助计量内码 比较(startswith)
   */
  private Long auxIdStartswith;
  /**
   * 辅助计量内码 比较(endswith)
   */
  private Long auxIdEndswith;
  /**
   * 辅助计量内码 比较(isnull)
   */
  private Boolean auxIdIsnull;
  /**
   * 辅助计量内码 比较(isnotnull)
   */
  private Boolean auxIdIsnotnull;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 库存数量
   */
  private java.math.BigDecimal stockQty;

  /**
   * 最小库存数量
   */
  private java.math.BigDecimal stockQtyMin;

  /**
   * 最大库存数量
   */
  private java.math.BigDecimal stockQtyMax;

  /**
   * 库存数量 比较(eq)
   */
  private java.math.BigDecimal stockQtyEq;
  /**
   * 库存数量 比较(neq)
   */
  private java.math.BigDecimal stockQtyNeq;
  /**
   * 库存数量 比较(gt)
   */
  private java.math.BigDecimal stockQtyGt;
  /**
   * 库存数量 比较(gte)
   */
  private java.math.BigDecimal stockQtyGte;
  /**
   * 库存数量 比较(lt)
   */
  private java.math.BigDecimal stockQtyLt;
  /**
   * 库存数量 比较(lte)
   */
  private java.math.BigDecimal stockQtyLte;
  /**
   * 库存数量 比较(contains)
   */
  private java.math.BigDecimal stockQtyContains;
  /**
   * 库存数量 比较(notcontains)
   */
  private java.math.BigDecimal stockQtyNotcontains;
  /**
   * 库存数量 比较(startswith)
   */
  private java.math.BigDecimal stockQtyStartswith;
  /**
   * 库存数量 比较(endswith)
   */
  private java.math.BigDecimal stockQtyEndswith;
  /**
   * 库存数量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 库存数量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 最早有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateStart;

  /**
   * 最晚有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateEnd;

  /**
   * 有效期至 比较(eq)
   */
  private Date expiryDateEq;
  /**
   * 有效期至 比较(neq)
   */
  private Date expiryDateNeq;
  /**
   * 有效期至 比较(gt)
   */
  private Date expiryDateGt;
  /**
   * 有效期至 比较(gte)
   */
  private Date expiryDateGte;
  /**
   * 有效期至 比较(lt)
   */
  private Date expiryDateLt;
  /**
   * 有效期至 比较(lte)
   */
  private Date expiryDateLte;
  /**
   * 有效期至 比较(contains)
   */
  private Date expiryDateContains;
  /**
   * 有效期至 比较(notcontains)
   */
  private Date expiryDateNotcontains;
  /**
   * 有效期至 比较(startswith)
   */
  private Date expiryDateStartswith;
  /**
   * 有效期至 比较(endswith)
   */
  private Date expiryDateEndswith;
  /**
   * 有效期至 比较(isnull)
   */
  private Boolean expiryDateIsnull;
  /**
   * 有效期至 比较(isnotnull)
   */
  private Boolean expiryDateIsnotnull;

  /**
   * 最早生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateStart;

  /**
   * 最晚生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateEnd;

  /**
   * 生产日期 比较(eq)
   */
  private Date productionDateEq;
  /**
   * 生产日期 比较(neq)
   */
  private Date productionDateNeq;
  /**
   * 生产日期 比较(gt)
   */
  private Date productionDateGt;
  /**
   * 生产日期 比较(gte)
   */
  private Date productionDateGte;
  /**
   * 生产日期 比较(lt)
   */
  private Date productionDateLt;
  /**
   * 生产日期 比较(lte)
   */
  private Date productionDateLte;
  /**
   * 生产日期 比较(contains)
   */
  private Date productionDateContains;
  /**
   * 生产日期 比较(notcontains)
   */
  private Date productionDateNotcontains;
  /**
   * 生产日期 比较(startswith)
   */
  private Date productionDateStartswith;
  /**
   * 生产日期 比较(endswith)
   */
  private Date productionDateEndswith;
  /**
   * 生产日期 比较(isnull)
   */
  private Boolean productionDateIsnull;
  /**
   * 生产日期 比较(isnotnull)
   */
  private Boolean productionDateIsnotnull;

  /**
   * 保质期(天)
   */
  private Long shelfLife;

  /**
   * 最小保质期(天)
   */
  private Long shelfLifeMin;

  /**
   * 最大保质期(天)
   */
  private Long shelfLifeMax;

  /**
   * 保质期(天) 比较(eq)
   */
  private Long shelfLifeEq;
  /**
   * 保质期(天) 比较(neq)
   */
  private Long shelfLifeNeq;
  /**
   * 保质期(天) 比较(gt)
   */
  private Long shelfLifeGt;
  /**
   * 保质期(天) 比较(gte)
   */
  private Long shelfLifeGte;
  /**
   * 保质期(天) 比较(lt)
   */
  private Long shelfLifeLt;
  /**
   * 保质期(天) 比较(lte)
   */
  private Long shelfLifeLte;
  /**
   * 保质期(天) 比较(contains)
   */
  private Long shelfLifeContains;
  /**
   * 保质期(天) 比较(notcontains)
   */
  private Long shelfLifeNotcontains;
  /**
   * 保质期(天) 比较(startswith)
   */
  private Long shelfLifeStartswith;
  /**
   * 保质期(天) 比较(endswith)
   */
  private Long shelfLifeEndswith;
  /**
   * 保质期(天) 比较(isnull)
   */
  private Boolean shelfLifeIsnull;
  /**
   * 保质期(天) 比较(isnotnull)
   */
  private Boolean shelfLifeIsnotnull;

  /**
   * 批号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 批号(精确搜索)
   */
  private List<String> batchNoInList;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 物料内码
   */
  private Long itemId;

  /**
   * 最小物料内码
   */
  private Long itemIdMin;

  /**
   * 最大物料内码
   */
  private Long itemIdMax;

  /**
   * 物料内码 比较(eq)
   */
  private Long itemIdEq;
  /**
   * 物料内码 比较(neq)
   */
  private Long itemIdNeq;
  /**
   * 物料内码 比较(gt)
   */
  private Long itemIdGt;
  /**
   * 物料内码 比较(gte)
   */
  private Long itemIdGte;
  /**
   * 物料内码 比较(lt)
   */
  private Long itemIdLt;
  /**
   * 物料内码 比较(lte)
   */
  private Long itemIdLte;
  /**
   * 物料内码 比较(contains)
   */
  private Long itemIdContains;
  /**
   * 物料内码 比较(notcontains)
   */
  private Long itemIdNotcontains;
  /**
   * 物料内码 比较(startswith)
   */
  private Long itemIdStartswith;
  /**
   * 物料内码 比较(endswith)
   */
  private Long itemIdEndswith;
  /**
   * 物料内码 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 物料内码 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;

  /**
   * 项目内码
   */
  private Long projectId;

  /**
   * 最小项目内码
   */
  private Long projectIdMin;

  /**
   * 最大项目内码
   */
  private Long projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Long projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Long projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Long projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Long projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Long projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Long projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Long projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Long projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Long projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Long projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 仓库内码
   */
  private Long stockId;

  /**
   * 最小仓库内码
   */
  private Long stockIdMin;

  /**
   * 最大仓库内码
   */
  private Long stockIdMax;

  /**
   * 仓库内码 比较(eq)
   */
  private Long stockIdEq;
  /**
   * 仓库内码 比较(neq)
   */
  private Long stockIdNeq;
  /**
   * 仓库内码 比较(gt)
   */
  private Long stockIdGt;
  /**
   * 仓库内码 比较(gte)
   */
  private Long stockIdGte;
  /**
   * 仓库内码 比较(lt)
   */
  private Long stockIdLt;
  /**
   * 仓库内码 比较(lte)
   */
  private Long stockIdLte;
  /**
   * 仓库内码 比较(contains)
   */
  private Long stockIdContains;
  /**
   * 仓库内码 比较(notcontains)
   */
  private Long stockIdNotcontains;
  /**
   * 仓库内码 比较(startswith)
   */
  private Long stockIdStartswith;
  /**
   * 仓库内码 比较(endswith)
   */
  private Long stockIdEndswith;
  /**
   * 仓库内码 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库内码 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
